// 获取当前激活的标签页并注入脚本
function injectScript() {
  try {
    chrome.tabs.query({ active: true, currentWindow: true }, function (tabs) {
      const tab = tabs[0];
      if (tab.id !== undefined && tab.url && !tab.url.startsWith('chrome://') && !tab.url.startsWith('about:')) {
        chrome.scripting.executeScript({
          target: { tabId: tab.id },
          func: capturePasswords
        }, function () {
          if (chrome.runtime.lastError) {
            console.error('脚本注入失败:', chrome.runtime.lastError);
          }
        });
        // setTimeout(() => autoFillIfMatch(tab), 1000); // 等待页面加载完成后再尝试自动填充
      } else {
        console.warn('无法在受限页面注入脚本:', tab.url);
      }
    });
  } catch (error) {
    console.error('injectScript 出错:', error);
  }
}

// URL 合法性检查函数
function isValidUrl(urlString) {
  if (typeof urlString !== 'string' || urlString.trim() === '') {
    return false;
  }
  try {
    new URL(urlString);
    return true;
  } catch (e) {
    return false;
  }
}

// 提取主域名（忽略子域），安全处理非法 URL
function getMainDomain(urlString) {
  if (typeof urlString !== 'string' || urlString.trim() === '') {
    return null;
  }

  // 预检查是否为合法 URL
  // if (!/^(https?:\/\/)/i.test(urlString)) {
  //   console.warn('非合法 URL 前缀，跳过解析:', urlString);
  //   return null;
  // }

  try {
    const url = new URL(urlString);
    const hostParts = url.hostname.split('.');
    if (hostParts.length >= 2) {
      return hostParts.slice(-2).join('.');
    }
    return url.hostname;
  } catch (e) {
    console.error('无法解析 URL:', urlString, e);
    return null;
  }
}

// 自动填充匹配的账号密码
function autoFillIfMatch(tab) {
  try {
    if (!tab.url || !isValidUrl(tab.url)) {
      console.warn('无效的页面 URL:', tab.url);
      return;
    }

    console.log('开始尝试自动填充，当前页面 URL:', tab.url, '标签页 ID:', tab.id);
    const currentMainDomain = getMainDomain(tab.url);
    if (!currentMainDomain) {
      console.warn('无法提取当前页面的主域名:', tab.url);
      return;
    }

    chrome.storage.local.get({ passwords: [] }, function (result) {
      const passwords = result.passwords;
      console.log('从 storage 中获取到的密码数据:', passwords);

      // 匹配主域名
      let match = passwords.find(entry => {
        if (!entry || typeof entry.url !== 'string') return false;
        const entryMainDomain = getMainDomain(entry.url);
        return entryMainDomain && entryMainDomain === currentMainDomain;
      });

      if (match) {
        console.log('找到匹配凭据，尝试自动填充:', match);
        // 首先确保脚本已注入
        chrome.scripting.executeScript({
          target: { tabId: tab.id },
          func: capturePasswords
        }, function () {
          if (chrome.runtime.lastError) {
            console.error('初始化脚本注入失败:', chrome.runtime.lastError);
          }
          
          // 然后执行填充
          chrome.scripting.executeScript({
            target: { tabId: tab.id },
            func: doFill,
            args: [match]
          }, function () {
            if (chrome.runtime.lastError) {
              console.error('自动填充脚本注入失败:', chrome.runtime.lastError);
            } else {
              console.log('自动填充脚本注入成功');
            }
          });
        });
      } else {
        console.log('未找到匹配的账号密码');
      }
    });
  } catch (error) {
    console.error('autoFillIfMatch 出错:', error);
  }
}

// 自定义快捷键监听器 - 现在只在内容脚本中设置
function setupCustomShortcut() {
  chrome.tabs.query({ active: true, currentWindow: true }, function (tabs) {
    const tab = tabs[0];
    if (tab.id !== undefined && tab.url && !tab.url.startsWith('chrome://') && !tab.url.startsWith('about:')) {
      // 注入包含快捷键逻辑的内容脚本
      chrome.scripting.executeScript({
        target: { tabId: tab.id },
        func: injectShortcutHandler
      }, function () {
        if (chrome.runtime.lastError) {
          console.error('注入快捷键处理器失败:', chrome.runtime.lastError);
        }
      });
    }
  });
}

// 在内容脚本中注入快捷键处理程序
function injectShortcutHandler() {
  document.addEventListener('keydown', function (e) {
    // 检测 Ctrl+Shift+F 或 Command+Shift+F
    if ((e.ctrlKey || e.metaKey) && e.shiftKey && e.code === 'KeyF') {
      e.preventDefault(); // 阻止浏览器默认查找功能
      
      // 发送消息给背景脚本执行自动填充
      chrome.runtime.sendMessage({ action: 'customShortcutTriggered' });
    }
  });
}

// 在目标页面执行填充操作
function doFill(entry) {
  try {
    console.log('doFill 正在执行，填充用户名:', entry.username, '密码:');//, entry.password
    const usernameInput = document.querySelector('input[type="text"], input[type="email"]');
    const passwordInput = document.querySelector('input[type="password"]');

    if (usernameInput) {
      usernameInput.value = entry.username;
      usernameInput.dispatchEvent(new Event('input', { bubbles: true }));
      usernameInput.dispatchEvent(new Event('change', { bubbles: true }));
      usernameInput.dispatchEvent(new Event('blur', { bubbles: true })); // 触发 blur 事件
      console.log('用户名已填充:', entry.username);
    } else {
      console.warn('未找到用户名输入框');
    }

    if (passwordInput) {
      passwordInput.value = entry.password;
      passwordInput.dispatchEvent(new Event('input', { bubbles: true }));
      passwordInput.dispatchEvent(new Event('change', { bubbles: true }));
      passwordInput.dispatchEvent(new Event('blur', { bubbles: true })); // 触发 blur 事件
      console.log('密码已填充');
    } else {
      console.warn('未找到密码输入框');
    }
  } catch (error) {
    console.error('doFill 执行出错:', error);
  }
}

// 快捷键触发自动填充
chrome.commands.onCommand.addListener(function (command) {
  if (command === 'fill-credentials-shortcut') {
    handleFillCredentialsShortcut();
  }
});

// 处理快捷键触发的自动填充
function handleFillCredentialsShortcut() {
  chrome.tabs.query({ active: true, currentWindow: true }, function (tabs) {
    const tab = tabs[0];
    if (tab.id !== undefined && tab.url && !tab.url.startsWith('chrome://') && !tab.url.startsWith('about:')) {
      console.log('快捷键触发，尝试自动填充:', tab.id);
      autoFillIfMatch(tab);
    }
  });
}

// 页面加载完成后注入脚本
chrome.runtime.onInstalled.addListener(() => {
  try {
    injectScript();
    setupCustomShortcut(); // 设置自定义快捷键
  } catch (error) {
    console.error('onInstalled 出错:', error);
  }
});

// 每次切换标签页时重新注入
chrome.tabs.onActivated.addListener(() => {
  try {
    injectScript();
    chrome.tabs.query({ active: true, currentWindow: true }, function (tabs) {
      const tab = tabs[0];
      if (tab.id !== undefined && tab.url && !tab.url.startsWith('chrome://') && !tab.url.startsWith('about:')) {
        // setTimeout(() => autoFillIfMatch(tab), 300); // 安全地使用 tab
        setupCustomShortcut(); // 在每次标签页激活时设置快捷键
      }
    });
  } catch (error) {
    console.error('标签页切换时出错:', error);
  }
});

// 每次更新标签页时注入
chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
  console.log(1)
  if (changeInfo.status === 'complete') {
    console.log('标签页加载完成:', tab.url);
    injectScript();
    setupCustomShortcut(); // 在标签页加载完成时设置快捷键
    
    // 延迟执行自动填充以确保页面元素已加载
    // setTimeout(() => {
    //   autoFillIfMatch(tab);
    // }, 500);
  }
});

// 消息监听器
chrome.runtime.onMessage.addListener(function (request, sender, sendResponse) {
  if (request.action === 'fillCredentials') {
    // 将填充操作委托给内容脚本
    chrome.tabs.query({ active: true, currentWindow: true }, function (tabs) {
      const tab = tabs[0];
      if (tab.id !== undefined && tab.url && !tab.url.startsWith('chrome://') && !tab.url.startsWith('about:')) {
        chrome.scripting.executeScript({
          target: { tabId: tab.id },
          func: doFill,
          args: [request.entry]
        }, function () {
          if (chrome.runtime.lastError) {
            console.error('自动填充脚本注入失败:', chrome.runtime.lastError);
          } else {
            console.log('自动填充脚本注入成功');
          }
        });
      }
    });
  } else if (request.action === 'customShortcutTriggered') {
    // 处理自定义快捷键触发的自动填充
    handleFillCredentialsShortcut();
  }
});

// 填充凭证函数 - 只保留后台逻辑
function fillCredentials(entry) {
  try {
    console.log('fillCredentials 正在执行，填充用户名:', entry.username, '密码:', entry.password);
    const usernameInput = document.querySelector('input[type="text"], input[type="email"]');
    const passwordInput = document.querySelector('input[type="password"]');

    if (usernameInput) {
      usernameInput.value = entry.username;
      usernameInput.dispatchEvent(new Event('input', { bubbles: true }));
      usernameInput.dispatchEvent(new Event('change', { bubbles: true }));
      usernameInput.dispatchEvent(new Event('blur', { bubbles: true })); // 触发 blur 事件
      console.log('用户名已填充:', entry.username);
    } else {
      console.warn('未找到用户名输入框');
    }

    if (passwordInput) {
      passwordInput.value = entry.password;
      passwordInput.dispatchEvent(new Event('input', { bubbles: true }));
      passwordInput.dispatchEvent(new Event('change', { bubbles: true }));
      passwordInput.dispatchEvent(new Event('blur', { bubbles: true })); // 触发 blur 事件
      console.log('密码已填充');
    } else {
      console.warn('未找到密码输入框');
    }
  } catch (error) {
    console.error('fillCredentials 执行出错:', error);
  }
}

// Background service worker for the extension
// This is required for the popup to communicate with the content script

// Listen for messages from the popup
chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
    // If we receive a message to get form info, forward it to the content script
    if (msg.type === 'GET_FORM_INFO') {
        chrome.scripting.executeScript({
            target: {tabId: sender.tab.id},
            func: getFormInfo
        });
    }
});

// Function to be injected into the page to gather form information
function getFormInfo() {
    const formFields = [];
    
    // Get all input elements on the page
    const inputs = document.querySelectorAll('input');
    inputs.forEach(input => {
        if (input.type === 'text' || input.type === 'email' || input.type === 'tel' || input.type === 'password') {
            formFields.push({
                name: input.name,
                type: input.type,
                id: input.id
            });
        }
    });
    
    // Send the form info back to the background script
    chrome.runtime.sendMessage({
        type: 'FORM_INFO',
        data: formFields
    });
}

// Function to be injected into the page to fill form fields
function fillFormFields(fieldMap) {
    Object.keys(fieldMap).forEach(fieldName => {
        const field = document.querySelector(`[name="${fieldName}"]`);
        if (field && field.type !== 'password') {
            field.value = fieldMap[fieldName];
            
            // 触发输入事件，以便网站的JavaScript可以响应变化
            const event = new Event('input', { bubbles: true });
            field.dispatchEvent(event);
        } else if (field && field.type === 'password') {
            field.value = fieldMap[fieldName];
            
            // 触发输入事件，以便网站的JavaScript可以响应变化
            const event = new Event('input', { bubbles: true });
            field.dispatchEvent(event);
        }
    });
}

// 捕获密码函数
function capturePasswords() {
  try {
    document.addEventListener('submit', function (event) {
      const forms = document.querySelectorAll('form');
      forms.forEach(form => {
        form.addEventListener('submit', function () {
          const inputs = form.querySelectorAll('input[type="password"]');
          if (inputs.length > 0) {
            const password = inputs[0].value;
            const usernameInput = form.querySelector('input[type="text"], input[type="email"]');
            const username = usernameInput ? usernameInput.value : 'unknown';
            const url = window.location.origin;

            chrome.storage.local.get({ passwords: [] }, function (result) {
              const existingData = result.passwords;
              const entryIndex = existingData.findIndex(entry => entry.url === url && entry.username === username);

              if (entryIndex === -1) {
                existingData.push({ url, username, password });
              } else {
                existingData[entryIndex].password = password;
              }

              chrome.storage.local.set({ passwords: existingData }, function () {
                console.log('密码已保存或更新');
              });
            });
          }
        });
      });
    });
  } catch (error) {
    console.error('capturePasswords 执行出错:', error);
  }
}